//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS ElasticsearchService service.
///
/// Amazon Elasticsearch Configuration Service Use the Amazon Elasticsearch Configuration API to create, configure, and manage Elasticsearch domains. For sample code that uses the Configuration API, see the Amazon Elasticsearch Service Developer Guide. The guide also contains sample code for sending signed HTTP requests to the Elasticsearch APIs. The endpoint for configuration service requests is region-specific: es.region.amazonaws.com. For example, es.us-east-1.amazonaws.com. For a current list of supported regions and endpoints, see Regions and Endpoints.
public struct ElasticsearchService: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the ElasticsearchService client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "ElasticsearchService",
            serviceIdentifier: "es",
            serviceProtocol: .restjson,
            apiVersion: "2015-01-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: ElasticsearchServiceErrorType.self,
            xmlNamespace: "http://es.amazonaws.com/doc/2015-01-01/",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "af-south-1": "aos.af-south-1.api.aws",
            "ap-east-1": "aos.ap-east-1.api.aws",
            "ap-northeast-1": "aos.ap-northeast-1.api.aws",
            "ap-northeast-2": "aos.ap-northeast-2.api.aws",
            "ap-northeast-3": "aos.ap-northeast-3.api.aws",
            "ap-south-1": "aos.ap-south-1.api.aws",
            "ap-south-2": "aos.ap-south-2.api.aws",
            "ap-southeast-1": "aos.ap-southeast-1.api.aws",
            "ap-southeast-2": "aos.ap-southeast-2.api.aws",
            "ap-southeast-3": "aos.ap-southeast-3.api.aws",
            "ap-southeast-4": "aos.ap-southeast-4.api.aws",
            "ap-southeast-5": "aos.ap-southeast-5.api.aws",
            "ap-southeast-7": "aos.ap-southeast-7.api.aws",
            "ca-central-1": "aos.ca-central-1.api.aws",
            "ca-west-1": "aos.ca-west-1.api.aws",
            "cn-north-1": "aos.cn-north-1.api.amazonwebservices.com.cn",
            "cn-northwest-1": "aos.cn-northwest-1.api.amazonwebservices.com.cn",
            "eu-central-1": "aos.eu-central-1.api.aws",
            "eu-central-2": "aos.eu-central-2.api.aws",
            "eu-north-1": "aos.eu-north-1.api.aws",
            "eu-south-1": "aos.eu-south-1.api.aws",
            "eu-south-2": "aos.eu-south-2.api.aws",
            "eu-west-1": "aos.eu-west-1.api.aws",
            "eu-west-2": "aos.eu-west-2.api.aws",
            "eu-west-3": "aos.eu-west-3.api.aws",
            "il-central-1": "aos.il-central-1.api.aws",
            "me-central-1": "aos.me-central-1.api.aws",
            "me-south-1": "aos.me-south-1.api.aws",
            "mx-central-1": "aos.mx-central-1.api.aws",
            "sa-east-1": "aos.sa-east-1.api.aws",
            "us-east-1": "aos.us-east-1.api.aws",
            "us-east-2": "aos.us-east-2.api.aws",
            "us-gov-east-1": "aos.us-gov-east-1.api.aws",
            "us-gov-west-1": "aos.us-gov-west-1.api.aws",
            "us-west-1": "aos.us-west-1.api.aws",
            "us-west-2": "aos.us-west-2.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "us-east-1": "es-fips.us-east-1.amazonaws.com",
            "us-east-2": "es-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "es-fips.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "es-fips.us-gov-west-1.amazonaws.com",
            "us-west-1": "es-fips.us-west-1.amazonaws.com",
            "us-west-2": "es-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Allows the destination domain owner to accept an inbound cross-cluster search connection request.
    @Sendable
    @inlinable
    public func acceptInboundCrossClusterSearchConnection(_ input: AcceptInboundCrossClusterSearchConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptInboundCrossClusterSearchConnectionResponse {
        try await self.client.execute(
            operation: "AcceptInboundCrossClusterSearchConnection", 
            path: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/accept", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows the destination domain owner to accept an inbound cross-cluster search connection request.
    ///
    /// Parameters:
    ///   - crossClusterSearchConnectionId: The id of the inbound connection that you want to accept.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptInboundCrossClusterSearchConnection(
        crossClusterSearchConnectionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptInboundCrossClusterSearchConnectionResponse {
        let input = AcceptInboundCrossClusterSearchConnectionRequest(
            crossClusterSearchConnectionId: crossClusterSearchConnectionId
        )
        return try await self.acceptInboundCrossClusterSearchConnection(input, logger: logger)
    }

    /// Attaches tags to an existing Elasticsearch domain. Tags are a set of case-sensitive key value pairs. An Elasticsearch domain may have up to 10 tags.  See  Tagging Amazon Elasticsearch Service Domains for more information.
    @Sendable
    @inlinable
    public func addTags(_ input: AddTagsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "AddTags", 
            path: "/2015-01-01/tags", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attaches tags to an existing Elasticsearch domain. Tags are a set of case-sensitive key value pairs. An Elasticsearch domain may have up to 10 tags.  See  Tagging Amazon Elasticsearch Service Domains for more information.
    ///
    /// Parameters:
    ///   - arn:  Specify the ARN for which you want to add the tags.
    ///   - tagList:  List of Tag that need to be added for the Elasticsearch domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func addTags(
        arn: String,
        tagList: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = AddTagsRequest(
            arn: arn, 
            tagList: tagList
        )
        return try await self.addTags(input, logger: logger)
    }

    /// Associates a package with an Amazon ES domain.
    @Sendable
    @inlinable
    public func associatePackage(_ input: AssociatePackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociatePackageResponse {
        try await self.client.execute(
            operation: "AssociatePackage", 
            path: "/2015-01-01/packages/associate/{PackageID}/{DomainName}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a package with an Amazon ES domain.
    ///
    /// Parameters:
    ///   - domainName: Name of the domain that you want to associate the package with.
    ///   - packageID: Internal ID of the package that you want to associate with a domain. Use DescribePackages to find this value.
    ///   - logger: Logger use during operation
    @inlinable
    public func associatePackage(
        domainName: String,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociatePackageResponse {
        let input = AssociatePackageRequest(
            domainName: domainName, 
            packageID: packageID
        )
        return try await self.associatePackage(input, logger: logger)
    }

    /// Provides access to an Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
    @Sendable
    @inlinable
    public func authorizeVpcEndpointAccess(_ input: AuthorizeVpcEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AuthorizeVpcEndpointAccessResponse {
        try await self.client.execute(
            operation: "AuthorizeVpcEndpointAccess", 
            path: "/2015-01-01/es/domain/{DomainName}/authorizeVpcEndpointAccess", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides access to an Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
    ///
    /// Parameters:
    ///   - account: The account ID to grant access to.
    ///   - domainName: The name of the OpenSearch Service domain to provide access to.
    ///   - logger: Logger use during operation
    @inlinable
    public func authorizeVpcEndpointAccess(
        account: String,
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AuthorizeVpcEndpointAccessResponse {
        let input = AuthorizeVpcEndpointAccessRequest(
            account: account, 
            domainName: domainName
        )
        return try await self.authorizeVpcEndpointAccess(input, logger: logger)
    }

    /// Cancels a pending configuration change on an Amazon OpenSearch Service domain.
    @Sendable
    @inlinable
    public func cancelDomainConfigChange(_ input: CancelDomainConfigChangeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelDomainConfigChangeResponse {
        try await self.client.execute(
            operation: "CancelDomainConfigChange", 
            path: "/2015-01-01/es/domain/{DomainName}/config/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a pending configuration change on an Amazon OpenSearch Service domain.
    ///
    /// Parameters:
    ///   - domainName: Name of the OpenSearch Service domain configuration request to cancel.
    ///   - dryRun: When set to True, returns the list of change IDs and properties that will be cancelled without actually cancelling the change.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelDomainConfigChange(
        domainName: String,
        dryRun: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelDomainConfigChangeResponse {
        let input = CancelDomainConfigChangeRequest(
            domainName: domainName, 
            dryRun: dryRun
        )
        return try await self.cancelDomainConfigChange(input, logger: logger)
    }

    /// Cancels a scheduled service software update for an Amazon ES domain. You can only perform this operation before the AutomatedUpdateDate and when the UpdateStatus is in the PENDING_UPDATE state.
    @Sendable
    @inlinable
    public func cancelElasticsearchServiceSoftwareUpdate(_ input: CancelElasticsearchServiceSoftwareUpdateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelElasticsearchServiceSoftwareUpdateResponse {
        try await self.client.execute(
            operation: "CancelElasticsearchServiceSoftwareUpdate", 
            path: "/2015-01-01/es/serviceSoftwareUpdate/cancel", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a scheduled service software update for an Amazon ES domain. You can only perform this operation before the AutomatedUpdateDate and when the UpdateStatus is in the PENDING_UPDATE state.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to stop the latest service software update on.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelElasticsearchServiceSoftwareUpdate(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelElasticsearchServiceSoftwareUpdateResponse {
        let input = CancelElasticsearchServiceSoftwareUpdateRequest(
            domainName: domainName
        )
        return try await self.cancelElasticsearchServiceSoftwareUpdate(input, logger: logger)
    }

    /// Creates a new Elasticsearch domain. For more information, see Creating Elasticsearch Domains in the Amazon Elasticsearch Service Developer Guide.
    @Sendable
    @inlinable
    public func createElasticsearchDomain(_ input: CreateElasticsearchDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateElasticsearchDomainResponse {
        try await self.client.execute(
            operation: "CreateElasticsearchDomain", 
            path: "/2015-01-01/es/domain", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new Elasticsearch domain. For more information, see Creating Elasticsearch Domains in the Amazon Elasticsearch Service Developer Guide.
    ///
    /// Parameters:
    ///   - accessPolicies:  IAM access policy as a JSON-formatted string.
    ///   - advancedOptions:  Option to allow references to indices in an HTTP request body.  Must be false when configuring access to individual sub-resources.  By default, the value is true. See Configuration Advanced Options for more information.
    ///   - advancedSecurityOptions: Specifies advanced security options.
    ///   - autoTuneOptions: Specifies Auto-Tune options.
    ///   - cognitoOptions: Options to specify the Cognito user and identity pools for Kibana authentication. For more information, see Amazon Cognito Authentication for Kibana.
    ///   - domainEndpointOptions: Options to specify configuration that will be applied to the domain endpoint.
    ///   - domainName: The name of the Elasticsearch domain that you are creating. Domain names are unique across the domains owned by an account within an AWS region. Domain names must start with a lowercase letter and can contain the following characters: a-z (lowercase), 0-9, and - (hyphen).
    ///   - ebsOptions: Options to enable, disable and specify the type and size of EBS storage volumes.
    ///   - elasticsearchClusterConfig: Configuration options for an Elasticsearch domain. Specifies the instance type and number of instances in the domain cluster.
    ///   - elasticsearchVersion: String of format X.Y to specify version for the Elasticsearch domain eg. "1.5" or "2.3". For more information, see Creating Elasticsearch Domains in the Amazon Elasticsearch Service Developer Guide.
    ///   - encryptionAtRestOptions: Specifies the Encryption At Rest Options.
    ///   - logPublishingOptions: Map of LogType and LogPublishingOption, each containing options to publish a given type of Elasticsearch log.
    ///   - nodeToNodeEncryptionOptions: Specifies the NodeToNodeEncryptionOptions.
    ///   - snapshotOptions: Option to set time, in UTC format, of the daily automated snapshot. Default value is 0 hours.
    ///   - tagList: A list of Tag added during domain creation.
    ///   - vpcOptions: Options to specify the subnets and security groups for VPC endpoint. For more information, see Creating a VPC in VPC Endpoints for Amazon Elasticsearch Service Domains
    ///   - logger: Logger use during operation
    @inlinable
    public func createElasticsearchDomain(
        accessPolicies: String? = nil,
        advancedOptions: [String: String]? = nil,
        advancedSecurityOptions: AdvancedSecurityOptionsInput? = nil,
        autoTuneOptions: AutoTuneOptionsInput? = nil,
        cognitoOptions: CognitoOptions? = nil,
        domainEndpointOptions: DomainEndpointOptions? = nil,
        domainName: String,
        ebsOptions: EBSOptions? = nil,
        elasticsearchClusterConfig: ElasticsearchClusterConfig? = nil,
        elasticsearchVersion: String? = nil,
        encryptionAtRestOptions: EncryptionAtRestOptions? = nil,
        logPublishingOptions: [LogType: LogPublishingOption]? = nil,
        nodeToNodeEncryptionOptions: NodeToNodeEncryptionOptions? = nil,
        snapshotOptions: SnapshotOptions? = nil,
        tagList: [Tag]? = nil,
        vpcOptions: VPCOptions? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateElasticsearchDomainResponse {
        let input = CreateElasticsearchDomainRequest(
            accessPolicies: accessPolicies, 
            advancedOptions: advancedOptions, 
            advancedSecurityOptions: advancedSecurityOptions, 
            autoTuneOptions: autoTuneOptions, 
            cognitoOptions: cognitoOptions, 
            domainEndpointOptions: domainEndpointOptions, 
            domainName: domainName, 
            ebsOptions: ebsOptions, 
            elasticsearchClusterConfig: elasticsearchClusterConfig, 
            elasticsearchVersion: elasticsearchVersion, 
            encryptionAtRestOptions: encryptionAtRestOptions, 
            logPublishingOptions: logPublishingOptions, 
            nodeToNodeEncryptionOptions: nodeToNodeEncryptionOptions, 
            snapshotOptions: snapshotOptions, 
            tagList: tagList, 
            vpcOptions: vpcOptions
        )
        return try await self.createElasticsearchDomain(input, logger: logger)
    }

    /// Creates a new cross-cluster search connection from a source domain to a destination domain.
    @Sendable
    @inlinable
    public func createOutboundCrossClusterSearchConnection(_ input: CreateOutboundCrossClusterSearchConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOutboundCrossClusterSearchConnectionResponse {
        try await self.client.execute(
            operation: "CreateOutboundCrossClusterSearchConnection", 
            path: "/2015-01-01/es/ccs/outboundConnection", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new cross-cluster search connection from a source domain to a destination domain.
    ///
    /// Parameters:
    ///   - connectionAlias: Specifies the connection alias that will be used by the customer for this connection.
    ///   - destinationDomainInfo: Specifies the DomainInformation for the destination Elasticsearch domain.
    ///   - sourceDomainInfo: Specifies the DomainInformation for the source Elasticsearch domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOutboundCrossClusterSearchConnection(
        connectionAlias: String,
        destinationDomainInfo: DomainInformation,
        sourceDomainInfo: DomainInformation,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOutboundCrossClusterSearchConnectionResponse {
        let input = CreateOutboundCrossClusterSearchConnectionRequest(
            connectionAlias: connectionAlias, 
            destinationDomainInfo: destinationDomainInfo, 
            sourceDomainInfo: sourceDomainInfo
        )
        return try await self.createOutboundCrossClusterSearchConnection(input, logger: logger)
    }

    /// Create a package for use with Amazon ES domains.
    @Sendable
    @inlinable
    public func createPackage(_ input: CreatePackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreatePackageResponse {
        try await self.client.execute(
            operation: "CreatePackage", 
            path: "/2015-01-01/packages", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a package for use with Amazon ES domains.
    ///
    /// Parameters:
    ///   - packageDescription: Description of the package.
    ///   - packageName: Unique identifier for the package.
    ///   - packageSource: The customer S3 location PackageSource for importing the package.
    ///   - packageType: Type of package. Currently supports only TXT-DICTIONARY.
    ///   - logger: Logger use during operation
    @inlinable
    public func createPackage(
        packageDescription: String? = nil,
        packageName: String,
        packageSource: PackageSource,
        packageType: PackageType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreatePackageResponse {
        let input = CreatePackageRequest(
            packageDescription: packageDescription, 
            packageName: packageName, 
            packageSource: packageSource, 
            packageType: packageType
        )
        return try await self.createPackage(input, logger: logger)
    }

    /// Creates an Amazon OpenSearch Service-managed VPC endpoint.
    @Sendable
    @inlinable
    public func createVpcEndpoint(_ input: CreateVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVpcEndpointResponse {
        try await self.client.execute(
            operation: "CreateVpcEndpoint", 
            path: "/2015-01-01/es/vpcEndpoints", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon OpenSearch Service-managed VPC endpoint.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - domainArn: The Amazon Resource Name (ARN) of the domain to grant access to.
    ///   - vpcOptions: Options to specify the subnets and security groups for the endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVpcEndpoint(
        clientToken: String? = nil,
        domainArn: String,
        vpcOptions: VPCOptions,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVpcEndpointResponse {
        let input = CreateVpcEndpointRequest(
            clientToken: clientToken, 
            domainArn: domainArn, 
            vpcOptions: vpcOptions
        )
        return try await self.createVpcEndpoint(input, logger: logger)
    }

    /// Permanently deletes the specified Elasticsearch domain and all of its data. Once a domain is deleted, it cannot be recovered.
    @Sendable
    @inlinable
    public func deleteElasticsearchDomain(_ input: DeleteElasticsearchDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteElasticsearchDomainResponse {
        try await self.client.execute(
            operation: "DeleteElasticsearchDomain", 
            path: "/2015-01-01/es/domain/{DomainName}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Permanently deletes the specified Elasticsearch domain and all of its data. Once a domain is deleted, it cannot be recovered.
    ///
    /// Parameters:
    ///   - domainName: The name of the Elasticsearch domain that you want to permanently delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteElasticsearchDomain(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteElasticsearchDomainResponse {
        let input = DeleteElasticsearchDomainRequest(
            domainName: domainName
        )
        return try await self.deleteElasticsearchDomain(input, logger: logger)
    }

    /// Deletes the service-linked role that Elasticsearch Service uses to manage and maintain VPC domains. Role deletion will fail if any existing VPC domains use the role. You must delete any such Elasticsearch domains before deleting the role. See Deleting Elasticsearch Service Role in VPC Endpoints for Amazon Elasticsearch Service Domains.
    @Sendable
    @inlinable
    public func deleteElasticsearchServiceRole(logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteElasticsearchServiceRole", 
            path: "/2015-01-01/es/role", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            logger: logger
        )
    }

    /// Allows the destination domain owner to delete an existing inbound cross-cluster search connection.
    @Sendable
    @inlinable
    public func deleteInboundCrossClusterSearchConnection(_ input: DeleteInboundCrossClusterSearchConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInboundCrossClusterSearchConnectionResponse {
        try await self.client.execute(
            operation: "DeleteInboundCrossClusterSearchConnection", 
            path: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows the destination domain owner to delete an existing inbound cross-cluster search connection.
    ///
    /// Parameters:
    ///   - crossClusterSearchConnectionId: The id of the inbound connection that you want to permanently delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInboundCrossClusterSearchConnection(
        crossClusterSearchConnectionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInboundCrossClusterSearchConnectionResponse {
        let input = DeleteInboundCrossClusterSearchConnectionRequest(
            crossClusterSearchConnectionId: crossClusterSearchConnectionId
        )
        return try await self.deleteInboundCrossClusterSearchConnection(input, logger: logger)
    }

    /// Allows the source domain owner to delete an existing outbound cross-cluster search connection.
    @Sendable
    @inlinable
    public func deleteOutboundCrossClusterSearchConnection(_ input: DeleteOutboundCrossClusterSearchConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteOutboundCrossClusterSearchConnectionResponse {
        try await self.client.execute(
            operation: "DeleteOutboundCrossClusterSearchConnection", 
            path: "/2015-01-01/es/ccs/outboundConnection/{CrossClusterSearchConnectionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows the source domain owner to delete an existing outbound cross-cluster search connection.
    ///
    /// Parameters:
    ///   - crossClusterSearchConnectionId: The id of the outbound connection that you want to permanently delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteOutboundCrossClusterSearchConnection(
        crossClusterSearchConnectionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteOutboundCrossClusterSearchConnectionResponse {
        let input = DeleteOutboundCrossClusterSearchConnectionRequest(
            crossClusterSearchConnectionId: crossClusterSearchConnectionId
        )
        return try await self.deleteOutboundCrossClusterSearchConnection(input, logger: logger)
    }

    /// Delete the package.
    @Sendable
    @inlinable
    public func deletePackage(_ input: DeletePackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeletePackageResponse {
        try await self.client.execute(
            operation: "DeletePackage", 
            path: "/2015-01-01/packages/{PackageID}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete the package.
    ///
    /// Parameters:
    ///   - packageID: Internal ID of the package that you want to delete. Use DescribePackages to find this value.
    ///   - logger: Logger use during operation
    @inlinable
    public func deletePackage(
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeletePackageResponse {
        let input = DeletePackageRequest(
            packageID: packageID
        )
        return try await self.deletePackage(input, logger: logger)
    }

    /// Deletes an Amazon OpenSearch Service-managed interface VPC endpoint.
    @Sendable
    @inlinable
    public func deleteVpcEndpoint(_ input: DeleteVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVpcEndpointResponse {
        try await self.client.execute(
            operation: "DeleteVpcEndpoint", 
            path: "/2015-01-01/es/vpcEndpoints/{VpcEndpointId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an Amazon OpenSearch Service-managed interface VPC endpoint.
    ///
    /// Parameters:
    ///   - vpcEndpointId: The unique identifier of the endpoint to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVpcEndpoint(
        vpcEndpointId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVpcEndpointResponse {
        let input = DeleteVpcEndpointRequest(
            vpcEndpointId: vpcEndpointId
        )
        return try await self.deleteVpcEndpoint(input, logger: logger)
    }

    /// Provides scheduled Auto-Tune action details for the Elasticsearch domain, such as Auto-Tune action type, description, severity, and scheduled date.
    @Sendable
    @inlinable
    public func describeDomainAutoTunes(_ input: DescribeDomainAutoTunesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeDomainAutoTunesResponse {
        try await self.client.execute(
            operation: "DescribeDomainAutoTunes", 
            path: "/2015-01-01/es/domain/{DomainName}/autoTunes", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides scheduled Auto-Tune action details for the Elasticsearch domain, such as Auto-Tune action type, description, severity, and scheduled date.
    ///
    /// Parameters:
    ///   - domainName: Specifies the domain name for which you want Auto-Tune action details.
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - nextToken: NextToken is sent in case the earlier API call results contain the NextToken. It is used for pagination.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeDomainAutoTunes(
        domainName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeDomainAutoTunesResponse {
        let input = DescribeDomainAutoTunesRequest(
            domainName: domainName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeDomainAutoTunes(input, logger: logger)
    }

    /// Returns information about the current blue/green deployment happening on a domain, including a change ID, status, and progress stages.
    @Sendable
    @inlinable
    public func describeDomainChangeProgress(_ input: DescribeDomainChangeProgressRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeDomainChangeProgressResponse {
        try await self.client.execute(
            operation: "DescribeDomainChangeProgress", 
            path: "/2015-01-01/es/domain/{DomainName}/progress", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the current blue/green deployment happening on a domain, including a change ID, status, and progress stages.
    ///
    /// Parameters:
    ///   - changeId: The specific change ID for which you want to get progress information. This is an optional parameter. If omitted, the service returns information about the most recent configuration change.
    ///   - domainName: The domain you want to get the progress information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeDomainChangeProgress(
        changeId: String? = nil,
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeDomainChangeProgressResponse {
        let input = DescribeDomainChangeProgressRequest(
            changeId: changeId, 
            domainName: domainName
        )
        return try await self.describeDomainChangeProgress(input, logger: logger)
    }

    /// Returns domain configuration information about the specified Elasticsearch domain, including the domain ID, domain endpoint, and domain ARN.
    @Sendable
    @inlinable
    public func describeElasticsearchDomain(_ input: DescribeElasticsearchDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeElasticsearchDomainResponse {
        try await self.client.execute(
            operation: "DescribeElasticsearchDomain", 
            path: "/2015-01-01/es/domain/{DomainName}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns domain configuration information about the specified Elasticsearch domain, including the domain ID, domain endpoint, and domain ARN.
    ///
    /// Parameters:
    ///   - domainName: The name of the Elasticsearch domain for which you want information.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeElasticsearchDomain(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeElasticsearchDomainResponse {
        let input = DescribeElasticsearchDomainRequest(
            domainName: domainName
        )
        return try await self.describeElasticsearchDomain(input, logger: logger)
    }

    /// Provides cluster configuration information about the specified Elasticsearch domain, such as the state, creation date, update version, and update date for cluster options.
    @Sendable
    @inlinable
    public func describeElasticsearchDomainConfig(_ input: DescribeElasticsearchDomainConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeElasticsearchDomainConfigResponse {
        try await self.client.execute(
            operation: "DescribeElasticsearchDomainConfig", 
            path: "/2015-01-01/es/domain/{DomainName}/config", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides cluster configuration information about the specified Elasticsearch domain, such as the state, creation date, update version, and update date for cluster options.
    ///
    /// Parameters:
    ///   - domainName: The Elasticsearch domain that you want to get information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeElasticsearchDomainConfig(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeElasticsearchDomainConfigResponse {
        let input = DescribeElasticsearchDomainConfigRequest(
            domainName: domainName
        )
        return try await self.describeElasticsearchDomainConfig(input, logger: logger)
    }

    /// Returns domain configuration information about the specified Elasticsearch domains, including the domain ID, domain endpoint, and domain ARN.
    @Sendable
    @inlinable
    public func describeElasticsearchDomains(_ input: DescribeElasticsearchDomainsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeElasticsearchDomainsResponse {
        try await self.client.execute(
            operation: "DescribeElasticsearchDomains", 
            path: "/2015-01-01/es/domain-info", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns domain configuration information about the specified Elasticsearch domains, including the domain ID, domain endpoint, and domain ARN.
    ///
    /// Parameters:
    ///   - domainNames: The Elasticsearch domains for which you want information.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeElasticsearchDomains(
        domainNames: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeElasticsearchDomainsResponse {
        let input = DescribeElasticsearchDomainsRequest(
            domainNames: domainNames
        )
        return try await self.describeElasticsearchDomains(input, logger: logger)
    }

    ///  Describe Elasticsearch Limits for a given InstanceType and ElasticsearchVersion. When modifying existing Domain, specify the  DomainName  to know what Limits are supported for modifying.
    @Sendable
    @inlinable
    public func describeElasticsearchInstanceTypeLimits(_ input: DescribeElasticsearchInstanceTypeLimitsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeElasticsearchInstanceTypeLimitsResponse {
        try await self.client.execute(
            operation: "DescribeElasticsearchInstanceTypeLimits", 
            path: "/2015-01-01/es/instanceTypeLimits/{ElasticsearchVersion}/{InstanceType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Describe Elasticsearch Limits for a given InstanceType and ElasticsearchVersion. When modifying existing Domain, specify the  DomainName  to know what Limits are supported for modifying.
    ///
    /// Parameters:
    ///   - domainName:  DomainName represents the name of the Domain that we are trying to modify. This should be present only if we are querying for Elasticsearch  Limits  for existing domain.
    ///   - elasticsearchVersion:  Version of Elasticsearch for which  Limits  are needed.
    ///   - instanceType:  The instance type for an Elasticsearch cluster for which Elasticsearch  Limits  are needed.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeElasticsearchInstanceTypeLimits(
        domainName: String? = nil,
        elasticsearchVersion: String,
        instanceType: ESPartitionInstanceType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeElasticsearchInstanceTypeLimitsResponse {
        let input = DescribeElasticsearchInstanceTypeLimitsRequest(
            domainName: domainName, 
            elasticsearchVersion: elasticsearchVersion, 
            instanceType: instanceType
        )
        return try await self.describeElasticsearchInstanceTypeLimits(input, logger: logger)
    }

    /// Lists all the inbound cross-cluster search connections for a destination domain.
    @Sendable
    @inlinable
    public func describeInboundCrossClusterSearchConnections(_ input: DescribeInboundCrossClusterSearchConnectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeInboundCrossClusterSearchConnectionsResponse {
        try await self.client.execute(
            operation: "DescribeInboundCrossClusterSearchConnections", 
            path: "/2015-01-01/es/ccs/inboundConnection/search", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the inbound cross-cluster search connections for a destination domain.
    ///
    /// Parameters:
    ///   - filters:  A list of filters used to match properties for inbound cross-cluster search connection. Available Filter names for this operation are:  cross-cluster-search-connection-id source-domain-info.domain-name source-domain-info.owner-id source-domain-info.region destination-domain-info.domain-name
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - nextToken:  NextToken is sent in case the earlier API call results contain the NextToken. It is used for pagination.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeInboundCrossClusterSearchConnections(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeInboundCrossClusterSearchConnectionsResponse {
        let input = DescribeInboundCrossClusterSearchConnectionsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeInboundCrossClusterSearchConnections(input, logger: logger)
    }

    /// Lists all the outbound cross-cluster search connections for a source domain.
    @Sendable
    @inlinable
    public func describeOutboundCrossClusterSearchConnections(_ input: DescribeOutboundCrossClusterSearchConnectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeOutboundCrossClusterSearchConnectionsResponse {
        try await self.client.execute(
            operation: "DescribeOutboundCrossClusterSearchConnections", 
            path: "/2015-01-01/es/ccs/outboundConnection/search", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the outbound cross-cluster search connections for a source domain.
    ///
    /// Parameters:
    ///   - filters:  A list of filters used to match properties for outbound cross-cluster search connection. Available Filter names for this operation are:  cross-cluster-search-connection-id destination-domain-info.domain-name destination-domain-info.owner-id destination-domain-info.region source-domain-info.domain-name
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - nextToken:  NextToken is sent in case the earlier API call results contain the NextToken. It is used for pagination.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeOutboundCrossClusterSearchConnections(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeOutboundCrossClusterSearchConnectionsResponse {
        let input = DescribeOutboundCrossClusterSearchConnectionsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describeOutboundCrossClusterSearchConnections(input, logger: logger)
    }

    /// Describes all packages available to Amazon ES. Includes options for filtering, limiting the number of results, and pagination.
    @Sendable
    @inlinable
    public func describePackages(_ input: DescribePackagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePackagesResponse {
        try await self.client.execute(
            operation: "DescribePackages", 
            path: "/2015-01-01/packages/describe", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes all packages available to Amazon ES. Includes options for filtering, limiting the number of results, and pagination.
    ///
    /// Parameters:
    ///   - filters: Only returns packages that match the DescribePackagesFilterList values.
    ///   - maxResults: Limits results to a maximum number of packages.
    ///   - nextToken: Used for pagination. Only necessary if a previous API call includes a non-null NextToken value. If provided, returns results for the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePackages(
        filters: [DescribePackagesFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePackagesResponse {
        let input = DescribePackagesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.describePackages(input, logger: logger)
    }

    /// Lists available reserved Elasticsearch instance offerings.
    @Sendable
    @inlinable
    public func describeReservedElasticsearchInstanceOfferings(_ input: DescribeReservedElasticsearchInstanceOfferingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReservedElasticsearchInstanceOfferingsResponse {
        try await self.client.execute(
            operation: "DescribeReservedElasticsearchInstanceOfferings", 
            path: "/2015-01-01/es/reservedInstanceOfferings", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists available reserved Elasticsearch instance offerings.
    ///
    /// Parameters:
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - nextToken: NextToken should be sent in case if earlier API call produced result
    ///   - reservedElasticsearchInstanceOfferingId: The offering identifier filter value. Use this parameter to show only the available offering that matches the specified reservation identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReservedElasticsearchInstanceOfferings(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        reservedElasticsearchInstanceOfferingId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReservedElasticsearchInstanceOfferingsResponse {
        let input = DescribeReservedElasticsearchInstanceOfferingsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            reservedElasticsearchInstanceOfferingId: reservedElasticsearchInstanceOfferingId
        )
        return try await self.describeReservedElasticsearchInstanceOfferings(input, logger: logger)
    }

    /// Returns information about reserved Elasticsearch instances for this account.
    @Sendable
    @inlinable
    public func describeReservedElasticsearchInstances(_ input: DescribeReservedElasticsearchInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReservedElasticsearchInstancesResponse {
        try await self.client.execute(
            operation: "DescribeReservedElasticsearchInstances", 
            path: "/2015-01-01/es/reservedInstances", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about reserved Elasticsearch instances for this account.
    ///
    /// Parameters:
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - nextToken: NextToken should be sent in case if earlier API call produced result
    ///   - reservedElasticsearchInstanceId: The reserved instance identifier filter value. Use this parameter to show only the reservation that matches the specified reserved Elasticsearch instance ID.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReservedElasticsearchInstances(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        reservedElasticsearchInstanceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReservedElasticsearchInstancesResponse {
        let input = DescribeReservedElasticsearchInstancesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            reservedElasticsearchInstanceId: reservedElasticsearchInstanceId
        )
        return try await self.describeReservedElasticsearchInstances(input, logger: logger)
    }

    /// Describes one or more Amazon OpenSearch Service-managed VPC endpoints.
    @Sendable
    @inlinable
    public func describeVpcEndpoints(_ input: DescribeVpcEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeVpcEndpointsResponse {
        try await self.client.execute(
            operation: "DescribeVpcEndpoints", 
            path: "/2015-01-01/es/vpcEndpoints/describe", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes one or more Amazon OpenSearch Service-managed VPC endpoints.
    ///
    /// Parameters:
    ///   - vpcEndpointIds: The unique identifiers of the endpoints to get information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeVpcEndpoints(
        vpcEndpointIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeVpcEndpointsResponse {
        let input = DescribeVpcEndpointsRequest(
            vpcEndpointIds: vpcEndpointIds
        )
        return try await self.describeVpcEndpoints(input, logger: logger)
    }

    /// Dissociates a package from the Amazon ES domain.
    @Sendable
    @inlinable
    public func dissociatePackage(_ input: DissociatePackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DissociatePackageResponse {
        try await self.client.execute(
            operation: "DissociatePackage", 
            path: "/2015-01-01/packages/dissociate/{PackageID}/{DomainName}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Dissociates a package from the Amazon ES domain.
    ///
    /// Parameters:
    ///   - domainName: Name of the domain that you want to associate the package with.
    ///   - packageID: Internal ID of the package that you want to associate with a domain. Use DescribePackages to find this value.
    ///   - logger: Logger use during operation
    @inlinable
    public func dissociatePackage(
        domainName: String,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DissociatePackageResponse {
        let input = DissociatePackageRequest(
            domainName: domainName, 
            packageID: packageID
        )
        return try await self.dissociatePackage(input, logger: logger)
    }

    ///  Returns a list of upgrade compatible Elastisearch versions. You can optionally pass a  DomainName  to get all upgrade compatible Elasticsearch versions for that specific domain.
    @Sendable
    @inlinable
    public func getCompatibleElasticsearchVersions(_ input: GetCompatibleElasticsearchVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCompatibleElasticsearchVersionsResponse {
        try await self.client.execute(
            operation: "GetCompatibleElasticsearchVersions", 
            path: "/2015-01-01/es/compatibleVersions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns a list of upgrade compatible Elastisearch versions. You can optionally pass a  DomainName  to get all upgrade compatible Elasticsearch versions for that specific domain.
    ///
    /// Parameters:
    ///   - domainName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getCompatibleElasticsearchVersions(
        domainName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCompatibleElasticsearchVersionsResponse {
        let input = GetCompatibleElasticsearchVersionsRequest(
            domainName: domainName
        )
        return try await self.getCompatibleElasticsearchVersions(input, logger: logger)
    }

    /// Returns a list of versions of the package, along with their creation time and commit message.
    @Sendable
    @inlinable
    public func getPackageVersionHistory(_ input: GetPackageVersionHistoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPackageVersionHistoryResponse {
        try await self.client.execute(
            operation: "GetPackageVersionHistory", 
            path: "/2015-01-01/packages/{PackageID}/history", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of versions of the package, along with their creation time and commit message.
    ///
    /// Parameters:
    ///   - maxResults: Limits results to a maximum number of versions.
    ///   - nextToken: Used for pagination. Only necessary if a previous API call includes a non-null NextToken value. If provided, returns results for the next page.
    ///   - packageID: Returns an audit history of versions of the package.
    ///   - logger: Logger use during operation
    @inlinable
    public func getPackageVersionHistory(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPackageVersionHistoryResponse {
        let input = GetPackageVersionHistoryRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            packageID: packageID
        )
        return try await self.getPackageVersionHistory(input, logger: logger)
    }

    /// Retrieves the complete history of the last 10 upgrades that were performed on the domain.
    @Sendable
    @inlinable
    public func getUpgradeHistory(_ input: GetUpgradeHistoryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUpgradeHistoryResponse {
        try await self.client.execute(
            operation: "GetUpgradeHistory", 
            path: "/2015-01-01/es/upgradeDomain/{DomainName}/history", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the complete history of the last 10 upgrades that were performed on the domain.
    ///
    /// Parameters:
    ///   - domainName: 
    ///   - maxResults: 
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getUpgradeHistory(
        domainName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUpgradeHistoryResponse {
        let input = GetUpgradeHistoryRequest(
            domainName: domainName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getUpgradeHistory(input, logger: logger)
    }

    /// Retrieves the latest status of the last upgrade or upgrade eligibility check that was performed on the domain.
    @Sendable
    @inlinable
    public func getUpgradeStatus(_ input: GetUpgradeStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUpgradeStatusResponse {
        try await self.client.execute(
            operation: "GetUpgradeStatus", 
            path: "/2015-01-01/es/upgradeDomain/{DomainName}/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the latest status of the last upgrade or upgrade eligibility check that was performed on the domain.
    ///
    /// Parameters:
    ///   - domainName: 
    ///   - logger: Logger use during operation
    @inlinable
    public func getUpgradeStatus(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUpgradeStatusResponse {
        let input = GetUpgradeStatusRequest(
            domainName: domainName
        )
        return try await self.getUpgradeStatus(input, logger: logger)
    }

    /// Returns the name of all Elasticsearch domains owned by the current user's account.
    @Sendable
    @inlinable
    public func listDomainNames(_ input: ListDomainNamesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDomainNamesResponse {
        try await self.client.execute(
            operation: "ListDomainNames", 
            path: "/2015-01-01/domain", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the name of all Elasticsearch domains owned by the current user's account.
    ///
    /// Parameters:
    ///   - engineType:  Optional parameter to filter the output by domain engine type. Acceptable values are 'Elasticsearch' and 'OpenSearch'.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDomainNames(
        engineType: EngineType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDomainNamesResponse {
        let input = ListDomainNamesRequest(
            engineType: engineType
        )
        return try await self.listDomainNames(input, logger: logger)
    }

    /// Lists all Amazon ES domains associated with the package.
    @Sendable
    @inlinable
    public func listDomainsForPackage(_ input: ListDomainsForPackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDomainsForPackageResponse {
        try await self.client.execute(
            operation: "ListDomainsForPackage", 
            path: "/2015-01-01/packages/{PackageID}/domains", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all Amazon ES domains associated with the package.
    ///
    /// Parameters:
    ///   - maxResults: Limits results to a maximum number of domains.
    ///   - nextToken: Used for pagination. Only necessary if a previous API call includes a non-null NextToken value. If provided, returns results for the next page.
    ///   - packageID: The package for which to list domains.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDomainsForPackage(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDomainsForPackageResponse {
        let input = ListDomainsForPackageRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            packageID: packageID
        )
        return try await self.listDomainsForPackage(input, logger: logger)
    }

    /// List all Elasticsearch instance types that are supported for given ElasticsearchVersion
    @Sendable
    @inlinable
    public func listElasticsearchInstanceTypes(_ input: ListElasticsearchInstanceTypesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListElasticsearchInstanceTypesResponse {
        try await self.client.execute(
            operation: "ListElasticsearchInstanceTypes", 
            path: "/2015-01-01/es/instanceTypes/{ElasticsearchVersion}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all Elasticsearch instance types that are supported for given ElasticsearchVersion
    ///
    /// Parameters:
    ///   - domainName: DomainName represents the name of the Domain that we are trying to modify. This should be present only if we are querying for list of available Elasticsearch instance types when modifying existing domain.
    ///   - elasticsearchVersion: Version of Elasticsearch for which list of supported elasticsearch instance types are needed.
    ///   - maxResults:  Set this value to limit the number of results returned. Value provided must be greater than 30 else it wont be honored.
    ///   - nextToken: NextToken should be sent in case if earlier API call produced result containing NextToken. It is used for pagination.
    ///   - logger: Logger use during operation
    @inlinable
    public func listElasticsearchInstanceTypes(
        domainName: String? = nil,
        elasticsearchVersion: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListElasticsearchInstanceTypesResponse {
        let input = ListElasticsearchInstanceTypesRequest(
            domainName: domainName, 
            elasticsearchVersion: elasticsearchVersion, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listElasticsearchInstanceTypes(input, logger: logger)
    }

    /// List all supported Elasticsearch versions
    @Sendable
    @inlinable
    public func listElasticsearchVersions(_ input: ListElasticsearchVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListElasticsearchVersionsResponse {
        try await self.client.execute(
            operation: "ListElasticsearchVersions", 
            path: "/2015-01-01/es/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all supported Elasticsearch versions
    ///
    /// Parameters:
    ///   - maxResults:  Set this value to limit the number of results returned. Value provided must be greater than 10 else it wont be honored.
    ///   - nextToken: 
    ///   - logger: Logger use during operation
    @inlinable
    public func listElasticsearchVersions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListElasticsearchVersionsResponse {
        let input = ListElasticsearchVersionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listElasticsearchVersions(input, logger: logger)
    }

    /// Lists all packages associated with the Amazon ES domain.
    @Sendable
    @inlinable
    public func listPackagesForDomain(_ input: ListPackagesForDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListPackagesForDomainResponse {
        try await self.client.execute(
            operation: "ListPackagesForDomain", 
            path: "/2015-01-01/domain/{DomainName}/packages", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all packages associated with the Amazon ES domain.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain for which you want to list associated packages.
    ///   - maxResults: Limits results to a maximum number of packages.
    ///   - nextToken: Used for pagination. Only necessary if a previous API call includes a non-null NextToken value. If provided, returns results for the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listPackagesForDomain(
        domainName: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListPackagesForDomainResponse {
        let input = ListPackagesForDomainRequest(
            domainName: domainName, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listPackagesForDomain(input, logger: logger)
    }

    /// Returns all tags for the given Elasticsearch domain.
    @Sendable
    @inlinable
    public func listTags(_ input: ListTagsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsResponse {
        try await self.client.execute(
            operation: "ListTags", 
            path: "/2015-01-01/tags", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns all tags for the given Elasticsearch domain.
    ///
    /// Parameters:
    ///   - arn:  Specify the ARN for the Elasticsearch domain to which the tags are attached that you want to view.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTags(
        arn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsResponse {
        let input = ListTagsRequest(
            arn: arn
        )
        return try await self.listTags(input, logger: logger)
    }

    /// Retrieves information about each  principal that is allowed to access a given Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
    @Sendable
    @inlinable
    public func listVpcEndpointAccess(_ input: ListVpcEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVpcEndpointAccessResponse {
        try await self.client.execute(
            operation: "ListVpcEndpointAccess", 
            path: "/2015-01-01/es/domain/{DomainName}/listVpcEndpointAccess", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about each  principal that is allowed to access a given Amazon OpenSearch Service domain through the use of an interface VPC endpoint.
    ///
    /// Parameters:
    ///   - domainName: The name of the OpenSearch Service domain to retrieve access information for.
    ///   - nextToken: Provides an identifier to allow retrieval of paginated results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVpcEndpointAccess(
        domainName: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVpcEndpointAccessResponse {
        let input = ListVpcEndpointAccessRequest(
            domainName: domainName, 
            nextToken: nextToken
        )
        return try await self.listVpcEndpointAccess(input, logger: logger)
    }

    /// Retrieves all Amazon OpenSearch Service-managed VPC endpoints in the current account and Region.
    @Sendable
    @inlinable
    public func listVpcEndpoints(_ input: ListVpcEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVpcEndpointsResponse {
        try await self.client.execute(
            operation: "ListVpcEndpoints", 
            path: "/2015-01-01/es/vpcEndpoints", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves all Amazon OpenSearch Service-managed VPC endpoints in the current account and Region.
    ///
    /// Parameters:
    ///   - nextToken: Identifier to allow retrieval of paginated results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVpcEndpoints(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVpcEndpointsResponse {
        let input = ListVpcEndpointsRequest(
            nextToken: nextToken
        )
        return try await self.listVpcEndpoints(input, logger: logger)
    }

    /// Retrieves all Amazon OpenSearch Service-managed VPC endpoints associated with a particular domain.
    @Sendable
    @inlinable
    public func listVpcEndpointsForDomain(_ input: ListVpcEndpointsForDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVpcEndpointsForDomainResponse {
        try await self.client.execute(
            operation: "ListVpcEndpointsForDomain", 
            path: "/2015-01-01/es/domain/{DomainName}/vpcEndpoints", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves all Amazon OpenSearch Service-managed VPC endpoints associated with a particular domain.
    ///
    /// Parameters:
    ///   - domainName: Name of the ElasticSearch domain whose VPC endpoints are to be listed.
    ///   - nextToken: Provides an identifier to allow retrieval of paginated results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVpcEndpointsForDomain(
        domainName: String,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVpcEndpointsForDomainResponse {
        let input = ListVpcEndpointsForDomainRequest(
            domainName: domainName, 
            nextToken: nextToken
        )
        return try await self.listVpcEndpointsForDomain(input, logger: logger)
    }

    /// Allows you to purchase reserved Elasticsearch instances.
    @Sendable
    @inlinable
    public func purchaseReservedElasticsearchInstanceOffering(_ input: PurchaseReservedElasticsearchInstanceOfferingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PurchaseReservedElasticsearchInstanceOfferingResponse {
        try await self.client.execute(
            operation: "PurchaseReservedElasticsearchInstanceOffering", 
            path: "/2015-01-01/es/purchaseReservedInstanceOffering", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows you to purchase reserved Elasticsearch instances.
    ///
    /// Parameters:
    ///   - instanceCount: The number of Elasticsearch instances to reserve.
    ///   - reservationName: A customer-specified identifier to track this reservation.
    ///   - reservedElasticsearchInstanceOfferingId: The ID of the reserved Elasticsearch instance offering to purchase.
    ///   - logger: Logger use during operation
    @inlinable
    public func purchaseReservedElasticsearchInstanceOffering(
        instanceCount: Int? = nil,
        reservationName: String,
        reservedElasticsearchInstanceOfferingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PurchaseReservedElasticsearchInstanceOfferingResponse {
        let input = PurchaseReservedElasticsearchInstanceOfferingRequest(
            instanceCount: instanceCount, 
            reservationName: reservationName, 
            reservedElasticsearchInstanceOfferingId: reservedElasticsearchInstanceOfferingId
        )
        return try await self.purchaseReservedElasticsearchInstanceOffering(input, logger: logger)
    }

    /// Allows the destination domain owner to reject an inbound cross-cluster search connection request.
    @Sendable
    @inlinable
    public func rejectInboundCrossClusterSearchConnection(_ input: RejectInboundCrossClusterSearchConnectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RejectInboundCrossClusterSearchConnectionResponse {
        try await self.client.execute(
            operation: "RejectInboundCrossClusterSearchConnection", 
            path: "/2015-01-01/es/ccs/inboundConnection/{CrossClusterSearchConnectionId}/reject", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows the destination domain owner to reject an inbound cross-cluster search connection request.
    ///
    /// Parameters:
    ///   - crossClusterSearchConnectionId: The id of the inbound connection that you want to reject.
    ///   - logger: Logger use during operation
    @inlinable
    public func rejectInboundCrossClusterSearchConnection(
        crossClusterSearchConnectionId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RejectInboundCrossClusterSearchConnectionResponse {
        let input = RejectInboundCrossClusterSearchConnectionRequest(
            crossClusterSearchConnectionId: crossClusterSearchConnectionId
        )
        return try await self.rejectInboundCrossClusterSearchConnection(input, logger: logger)
    }

    /// Removes the specified set of tags from the specified Elasticsearch domain.
    @Sendable
    @inlinable
    public func removeTags(_ input: RemoveTagsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "RemoveTags", 
            path: "/2015-01-01/tags-removal", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified set of tags from the specified Elasticsearch domain.
    ///
    /// Parameters:
    ///   - arn: Specifies the ARN for the Elasticsearch domain from which you want to delete the specified tags.
    ///   - tagKeys: Specifies the TagKey list which you want to remove from the Elasticsearch domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeTags(
        arn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = RemoveTagsRequest(
            arn: arn, 
            tagKeys: tagKeys
        )
        return try await self.removeTags(input, logger: logger)
    }

    /// Revokes access to an Amazon OpenSearch Service domain that was provided through an interface VPC endpoint.
    @Sendable
    @inlinable
    public func revokeVpcEndpointAccess(_ input: RevokeVpcEndpointAccessRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RevokeVpcEndpointAccessResponse {
        try await self.client.execute(
            operation: "RevokeVpcEndpointAccess", 
            path: "/2015-01-01/es/domain/{DomainName}/revokeVpcEndpointAccess", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Revokes access to an Amazon OpenSearch Service domain that was provided through an interface VPC endpoint.
    ///
    /// Parameters:
    ///   - account: The account ID to revoke access from.
    ///   - domainName: The name of the OpenSearch Service domain.
    ///   - logger: Logger use during operation
    @inlinable
    public func revokeVpcEndpointAccess(
        account: String,
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RevokeVpcEndpointAccessResponse {
        let input = RevokeVpcEndpointAccessRequest(
            account: account, 
            domainName: domainName
        )
        return try await self.revokeVpcEndpointAccess(input, logger: logger)
    }

    /// Schedules a service software update for an Amazon ES domain.
    @Sendable
    @inlinable
    public func startElasticsearchServiceSoftwareUpdate(_ input: StartElasticsearchServiceSoftwareUpdateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartElasticsearchServiceSoftwareUpdateResponse {
        try await self.client.execute(
            operation: "StartElasticsearchServiceSoftwareUpdate", 
            path: "/2015-01-01/es/serviceSoftwareUpdate/start", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Schedules a service software update for an Amazon ES domain.
    ///
    /// Parameters:
    ///   - domainName: The name of the domain that you want to update to the latest service software.
    ///   - logger: Logger use during operation
    @inlinable
    public func startElasticsearchServiceSoftwareUpdate(
        domainName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartElasticsearchServiceSoftwareUpdateResponse {
        let input = StartElasticsearchServiceSoftwareUpdateRequest(
            domainName: domainName
        )
        return try await self.startElasticsearchServiceSoftwareUpdate(input, logger: logger)
    }

    /// Modifies the cluster configuration of the specified Elasticsearch domain, setting as setting the instance type and the number of instances.
    @Sendable
    @inlinable
    public func updateElasticsearchDomainConfig(_ input: UpdateElasticsearchDomainConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateElasticsearchDomainConfigResponse {
        try await self.client.execute(
            operation: "UpdateElasticsearchDomainConfig", 
            path: "/2015-01-01/es/domain/{DomainName}/config", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the cluster configuration of the specified Elasticsearch domain, setting as setting the instance type and the number of instances.
    ///
    /// Parameters:
    ///   - accessPolicies: IAM access policy as a JSON-formatted string.
    ///   - advancedOptions: Modifies the advanced option to allow references to indices in an HTTP request body.  Must be false when configuring access to individual sub-resources.  By default, the value is true. See Configuration Advanced Options for more information.
    ///   - advancedSecurityOptions: Specifies advanced security options.
    ///   - autoTuneOptions: Specifies Auto-Tune options.
    ///   - cognitoOptions: Options to specify the Cognito user and identity pools for Kibana authentication. For more information, see Amazon Cognito Authentication for Kibana.
    ///   - domainEndpointOptions: Options to specify configuration that will be applied to the domain endpoint.
    ///   - domainName: The name of the Elasticsearch domain that you are updating.
    ///   - dryRun:  This flag, when set to True, specifies whether the UpdateElasticsearchDomain request should return the results of validation checks without actually applying the change. This flag, when set to True, specifies the deployment mechanism through which the update shall be applied on the domain. This will not actually perform the Update.
    ///   - ebsOptions: Specify the type and size of the EBS volume that you want to use.
    ///   - elasticsearchClusterConfig: The type and number of instances to instantiate for the domain cluster.
    ///   - encryptionAtRestOptions: Specifies the Encryption At Rest Options.
    ///   - logPublishingOptions: Map of LogType and LogPublishingOption, each containing options to publish a given type of Elasticsearch log.
    ///   - nodeToNodeEncryptionOptions: Specifies the NodeToNodeEncryptionOptions.
    ///   - snapshotOptions: Option to set the time, in UTC format, for the daily automated snapshot. Default value is 0 hours.
    ///   - vpcOptions: Options to specify the subnets and security groups for VPC endpoint. For more information, see Creating a VPC in VPC Endpoints for Amazon Elasticsearch Service Domains
    ///   - logger: Logger use during operation
    @inlinable
    public func updateElasticsearchDomainConfig(
        accessPolicies: String? = nil,
        advancedOptions: [String: String]? = nil,
        advancedSecurityOptions: AdvancedSecurityOptionsInput? = nil,
        autoTuneOptions: AutoTuneOptions? = nil,
        cognitoOptions: CognitoOptions? = nil,
        domainEndpointOptions: DomainEndpointOptions? = nil,
        domainName: String,
        dryRun: Bool? = nil,
        ebsOptions: EBSOptions? = nil,
        elasticsearchClusterConfig: ElasticsearchClusterConfig? = nil,
        encryptionAtRestOptions: EncryptionAtRestOptions? = nil,
        logPublishingOptions: [LogType: LogPublishingOption]? = nil,
        nodeToNodeEncryptionOptions: NodeToNodeEncryptionOptions? = nil,
        snapshotOptions: SnapshotOptions? = nil,
        vpcOptions: VPCOptions? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateElasticsearchDomainConfigResponse {
        let input = UpdateElasticsearchDomainConfigRequest(
            accessPolicies: accessPolicies, 
            advancedOptions: advancedOptions, 
            advancedSecurityOptions: advancedSecurityOptions, 
            autoTuneOptions: autoTuneOptions, 
            cognitoOptions: cognitoOptions, 
            domainEndpointOptions: domainEndpointOptions, 
            domainName: domainName, 
            dryRun: dryRun, 
            ebsOptions: ebsOptions, 
            elasticsearchClusterConfig: elasticsearchClusterConfig, 
            encryptionAtRestOptions: encryptionAtRestOptions, 
            logPublishingOptions: logPublishingOptions, 
            nodeToNodeEncryptionOptions: nodeToNodeEncryptionOptions, 
            snapshotOptions: snapshotOptions, 
            vpcOptions: vpcOptions
        )
        return try await self.updateElasticsearchDomainConfig(input, logger: logger)
    }

    /// Updates a package for use with Amazon ES domains.
    @Sendable
    @inlinable
    public func updatePackage(_ input: UpdatePackageRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdatePackageResponse {
        try await self.client.execute(
            operation: "UpdatePackage", 
            path: "/2015-01-01/packages/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a package for use with Amazon ES domains.
    ///
    /// Parameters:
    ///   - commitMessage: An info message for the new version which will be shown as part of GetPackageVersionHistoryResponse.
    ///   - packageDescription: New description of the package.
    ///   - packageID: Unique identifier for the package.
    ///   - packageSource: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updatePackage(
        commitMessage: String? = nil,
        packageDescription: String? = nil,
        packageID: String,
        packageSource: PackageSource,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdatePackageResponse {
        let input = UpdatePackageRequest(
            commitMessage: commitMessage, 
            packageDescription: packageDescription, 
            packageID: packageID, 
            packageSource: packageSource
        )
        return try await self.updatePackage(input, logger: logger)
    }

    /// Modifies an Amazon OpenSearch Service-managed interface VPC endpoint.
    @Sendable
    @inlinable
    public func updateVpcEndpoint(_ input: UpdateVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVpcEndpointResponse {
        try await self.client.execute(
            operation: "UpdateVpcEndpoint", 
            path: "/2015-01-01/es/vpcEndpoints/update", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies an Amazon OpenSearch Service-managed interface VPC endpoint.
    ///
    /// Parameters:
    ///   - vpcEndpointId: Unique identifier of the VPC endpoint to be updated.
    ///   - vpcOptions: The security groups and/or subnets to add, remove, or modify.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVpcEndpoint(
        vpcEndpointId: String,
        vpcOptions: VPCOptions,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVpcEndpointResponse {
        let input = UpdateVpcEndpointRequest(
            vpcEndpointId: vpcEndpointId, 
            vpcOptions: vpcOptions
        )
        return try await self.updateVpcEndpoint(input, logger: logger)
    }

    /// Allows you to either upgrade your domain or perform an Upgrade eligibility check to a compatible Elasticsearch version.
    @Sendable
    @inlinable
    public func upgradeElasticsearchDomain(_ input: UpgradeElasticsearchDomainRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpgradeElasticsearchDomainResponse {
        try await self.client.execute(
            operation: "UpgradeElasticsearchDomain", 
            path: "/2015-01-01/es/upgradeDomain", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Allows you to either upgrade your domain or perform an Upgrade eligibility check to a compatible Elasticsearch version.
    ///
    /// Parameters:
    ///   - domainName: 
    ///   - performCheckOnly:  This flag, when set to True, indicates that an Upgrade Eligibility Check needs to be performed. This will not actually perform the Upgrade.
    ///   - targetVersion: The version of Elasticsearch that you intend to upgrade the domain to.
    ///   - logger: Logger use during operation
    @inlinable
    public func upgradeElasticsearchDomain(
        domainName: String,
        performCheckOnly: Bool? = nil,
        targetVersion: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpgradeElasticsearchDomainResponse {
        let input = UpgradeElasticsearchDomainRequest(
            domainName: domainName, 
            performCheckOnly: performCheckOnly, 
            targetVersion: targetVersion
        )
        return try await self.upgradeElasticsearchDomain(input, logger: logger)
    }
}

extension ElasticsearchService {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: ElasticsearchService, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension ElasticsearchService {
    /// Return PaginatorSequence for operation ``describeDomainAutoTunes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDomainAutoTunesPaginator(
        _ input: DescribeDomainAutoTunesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeDomainAutoTunesRequest, DescribeDomainAutoTunesResponse> {
        return .init(
            input: input,
            command: self.describeDomainAutoTunes,
            inputKey: \DescribeDomainAutoTunesRequest.nextToken,
            outputKey: \DescribeDomainAutoTunesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeDomainAutoTunes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainName: Specifies the domain name for which you want Auto-Tune action details.
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDomainAutoTunesPaginator(
        domainName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeDomainAutoTunesRequest, DescribeDomainAutoTunesResponse> {
        let input = DescribeDomainAutoTunesRequest(
            domainName: domainName, 
            maxResults: maxResults
        )
        return self.describeDomainAutoTunesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeInboundCrossClusterSearchConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeInboundCrossClusterSearchConnectionsPaginator(
        _ input: DescribeInboundCrossClusterSearchConnectionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeInboundCrossClusterSearchConnectionsRequest, DescribeInboundCrossClusterSearchConnectionsResponse> {
        return .init(
            input: input,
            command: self.describeInboundCrossClusterSearchConnections,
            inputKey: \DescribeInboundCrossClusterSearchConnectionsRequest.nextToken,
            outputKey: \DescribeInboundCrossClusterSearchConnectionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeInboundCrossClusterSearchConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  A list of filters used to match properties for inbound cross-cluster search connection. Available Filter names for this operation are:  cross-cluster-search-connection-id source-domain-info.domain-name source-domain-info.owner-id source-domain-info.region destination-domain-info.domain-name
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeInboundCrossClusterSearchConnectionsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeInboundCrossClusterSearchConnectionsRequest, DescribeInboundCrossClusterSearchConnectionsResponse> {
        let input = DescribeInboundCrossClusterSearchConnectionsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.describeInboundCrossClusterSearchConnectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeOutboundCrossClusterSearchConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeOutboundCrossClusterSearchConnectionsPaginator(
        _ input: DescribeOutboundCrossClusterSearchConnectionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeOutboundCrossClusterSearchConnectionsRequest, DescribeOutboundCrossClusterSearchConnectionsResponse> {
        return .init(
            input: input,
            command: self.describeOutboundCrossClusterSearchConnections,
            inputKey: \DescribeOutboundCrossClusterSearchConnectionsRequest.nextToken,
            outputKey: \DescribeOutboundCrossClusterSearchConnectionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeOutboundCrossClusterSearchConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  A list of filters used to match properties for outbound cross-cluster search connection. Available Filter names for this operation are:  cross-cluster-search-connection-id destination-domain-info.domain-name destination-domain-info.owner-id destination-domain-info.region source-domain-info.domain-name
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeOutboundCrossClusterSearchConnectionsPaginator(
        filters: [Filter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeOutboundCrossClusterSearchConnectionsRequest, DescribeOutboundCrossClusterSearchConnectionsResponse> {
        let input = DescribeOutboundCrossClusterSearchConnectionsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.describeOutboundCrossClusterSearchConnectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describePackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describePackagesPaginator(
        _ input: DescribePackagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribePackagesRequest, DescribePackagesResponse> {
        return .init(
            input: input,
            command: self.describePackages,
            inputKey: \DescribePackagesRequest.nextToken,
            outputKey: \DescribePackagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describePackages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Only returns packages that match the DescribePackagesFilterList values.
    ///   - maxResults: Limits results to a maximum number of packages.
    ///   - logger: Logger used for logging
    @inlinable
    public func describePackagesPaginator(
        filters: [DescribePackagesFilter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribePackagesRequest, DescribePackagesResponse> {
        let input = DescribePackagesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.describePackagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReservedElasticsearchInstanceOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReservedElasticsearchInstanceOfferingsPaginator(
        _ input: DescribeReservedElasticsearchInstanceOfferingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReservedElasticsearchInstanceOfferingsRequest, DescribeReservedElasticsearchInstanceOfferingsResponse> {
        return .init(
            input: input,
            command: self.describeReservedElasticsearchInstanceOfferings,
            inputKey: \DescribeReservedElasticsearchInstanceOfferingsRequest.nextToken,
            outputKey: \DescribeReservedElasticsearchInstanceOfferingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReservedElasticsearchInstanceOfferings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - reservedElasticsearchInstanceOfferingId: The offering identifier filter value. Use this parameter to show only the available offering that matches the specified reservation identifier.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReservedElasticsearchInstanceOfferingsPaginator(
        maxResults: Int? = nil,
        reservedElasticsearchInstanceOfferingId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReservedElasticsearchInstanceOfferingsRequest, DescribeReservedElasticsearchInstanceOfferingsResponse> {
        let input = DescribeReservedElasticsearchInstanceOfferingsRequest(
            maxResults: maxResults, 
            reservedElasticsearchInstanceOfferingId: reservedElasticsearchInstanceOfferingId
        )
        return self.describeReservedElasticsearchInstanceOfferingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReservedElasticsearchInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReservedElasticsearchInstancesPaginator(
        _ input: DescribeReservedElasticsearchInstancesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReservedElasticsearchInstancesRequest, DescribeReservedElasticsearchInstancesResponse> {
        return .init(
            input: input,
            command: self.describeReservedElasticsearchInstances,
            inputKey: \DescribeReservedElasticsearchInstancesRequest.nextToken,
            outputKey: \DescribeReservedElasticsearchInstancesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReservedElasticsearchInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Set this value to limit the number of results returned. If not specified, defaults to 100.
    ///   - reservedElasticsearchInstanceId: The reserved instance identifier filter value. Use this parameter to show only the reservation that matches the specified reserved Elasticsearch instance ID.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReservedElasticsearchInstancesPaginator(
        maxResults: Int? = nil,
        reservedElasticsearchInstanceId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReservedElasticsearchInstancesRequest, DescribeReservedElasticsearchInstancesResponse> {
        let input = DescribeReservedElasticsearchInstancesRequest(
            maxResults: maxResults, 
            reservedElasticsearchInstanceId: reservedElasticsearchInstanceId
        )
        return self.describeReservedElasticsearchInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getPackageVersionHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getPackageVersionHistoryPaginator(
        _ input: GetPackageVersionHistoryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetPackageVersionHistoryRequest, GetPackageVersionHistoryResponse> {
        return .init(
            input: input,
            command: self.getPackageVersionHistory,
            inputKey: \GetPackageVersionHistoryRequest.nextToken,
            outputKey: \GetPackageVersionHistoryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getPackageVersionHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Limits results to a maximum number of versions.
    ///   - packageID: Returns an audit history of versions of the package.
    ///   - logger: Logger used for logging
    @inlinable
    public func getPackageVersionHistoryPaginator(
        maxResults: Int? = nil,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetPackageVersionHistoryRequest, GetPackageVersionHistoryResponse> {
        let input = GetPackageVersionHistoryRequest(
            maxResults: maxResults, 
            packageID: packageID
        )
        return self.getPackageVersionHistoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getUpgradeHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getUpgradeHistoryPaginator(
        _ input: GetUpgradeHistoryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetUpgradeHistoryRequest, GetUpgradeHistoryResponse> {
        return .init(
            input: input,
            command: self.getUpgradeHistory,
            inputKey: \GetUpgradeHistoryRequest.nextToken,
            outputKey: \GetUpgradeHistoryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getUpgradeHistory(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainName: 
    ///   - maxResults: 
    ///   - logger: Logger used for logging
    @inlinable
    public func getUpgradeHistoryPaginator(
        domainName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetUpgradeHistoryRequest, GetUpgradeHistoryResponse> {
        let input = GetUpgradeHistoryRequest(
            domainName: domainName, 
            maxResults: maxResults
        )
        return self.getUpgradeHistoryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDomainsForPackage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsForPackagePaginator(
        _ input: ListDomainsForPackageRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDomainsForPackageRequest, ListDomainsForPackageResponse> {
        return .init(
            input: input,
            command: self.listDomainsForPackage,
            inputKey: \ListDomainsForPackageRequest.nextToken,
            outputKey: \ListDomainsForPackageResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDomainsForPackage(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: Limits results to a maximum number of domains.
    ///   - packageID: The package for which to list domains.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDomainsForPackagePaginator(
        maxResults: Int? = nil,
        packageID: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDomainsForPackageRequest, ListDomainsForPackageResponse> {
        let input = ListDomainsForPackageRequest(
            maxResults: maxResults, 
            packageID: packageID
        )
        return self.listDomainsForPackagePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listElasticsearchInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listElasticsearchInstanceTypesPaginator(
        _ input: ListElasticsearchInstanceTypesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListElasticsearchInstanceTypesRequest, ListElasticsearchInstanceTypesResponse> {
        return .init(
            input: input,
            command: self.listElasticsearchInstanceTypes,
            inputKey: \ListElasticsearchInstanceTypesRequest.nextToken,
            outputKey: \ListElasticsearchInstanceTypesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listElasticsearchInstanceTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainName: DomainName represents the name of the Domain that we are trying to modify. This should be present only if we are querying for list of available Elasticsearch instance types when modifying existing domain.
    ///   - elasticsearchVersion: Version of Elasticsearch for which list of supported elasticsearch instance types are needed.
    ///   - maxResults:  Set this value to limit the number of results returned. Value provided must be greater than 30 else it wont be honored.
    ///   - logger: Logger used for logging
    @inlinable
    public func listElasticsearchInstanceTypesPaginator(
        domainName: String? = nil,
        elasticsearchVersion: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListElasticsearchInstanceTypesRequest, ListElasticsearchInstanceTypesResponse> {
        let input = ListElasticsearchInstanceTypesRequest(
            domainName: domainName, 
            elasticsearchVersion: elasticsearchVersion, 
            maxResults: maxResults
        )
        return self.listElasticsearchInstanceTypesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listElasticsearchVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listElasticsearchVersionsPaginator(
        _ input: ListElasticsearchVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListElasticsearchVersionsRequest, ListElasticsearchVersionsResponse> {
        return .init(
            input: input,
            command: self.listElasticsearchVersions,
            inputKey: \ListElasticsearchVersionsRequest.nextToken,
            outputKey: \ListElasticsearchVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listElasticsearchVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults:  Set this value to limit the number of results returned. Value provided must be greater than 10 else it wont be honored.
    ///   - logger: Logger used for logging
    @inlinable
    public func listElasticsearchVersionsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListElasticsearchVersionsRequest, ListElasticsearchVersionsResponse> {
        let input = ListElasticsearchVersionsRequest(
            maxResults: maxResults
        )
        return self.listElasticsearchVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listPackagesForDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listPackagesForDomainPaginator(
        _ input: ListPackagesForDomainRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListPackagesForDomainRequest, ListPackagesForDomainResponse> {
        return .init(
            input: input,
            command: self.listPackagesForDomain,
            inputKey: \ListPackagesForDomainRequest.nextToken,
            outputKey: \ListPackagesForDomainResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listPackagesForDomain(_:logger:)``.
    ///
    /// - Parameters:
    ///   - domainName: The name of the domain for which you want to list associated packages.
    ///   - maxResults: Limits results to a maximum number of packages.
    ///   - logger: Logger used for logging
    @inlinable
    public func listPackagesForDomainPaginator(
        domainName: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListPackagesForDomainRequest, ListPackagesForDomainResponse> {
        let input = ListPackagesForDomainRequest(
            domainName: domainName, 
            maxResults: maxResults
        )
        return self.listPackagesForDomainPaginator(input, logger: logger)
    }
}

extension ElasticsearchService.DescribeDomainAutoTunesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribeDomainAutoTunesRequest {
        return .init(
            domainName: self.domainName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.DescribeInboundCrossClusterSearchConnectionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribeInboundCrossClusterSearchConnectionsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.DescribeOutboundCrossClusterSearchConnectionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribeOutboundCrossClusterSearchConnectionsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.DescribePackagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribePackagesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.DescribeReservedElasticsearchInstanceOfferingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribeReservedElasticsearchInstanceOfferingsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            reservedElasticsearchInstanceOfferingId: self.reservedElasticsearchInstanceOfferingId
        )
    }
}

extension ElasticsearchService.DescribeReservedElasticsearchInstancesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.DescribeReservedElasticsearchInstancesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            reservedElasticsearchInstanceId: self.reservedElasticsearchInstanceId
        )
    }
}

extension ElasticsearchService.GetPackageVersionHistoryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.GetPackageVersionHistoryRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            packageID: self.packageID
        )
    }
}

extension ElasticsearchService.GetUpgradeHistoryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.GetUpgradeHistoryRequest {
        return .init(
            domainName: self.domainName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.ListDomainsForPackageRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.ListDomainsForPackageRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            packageID: self.packageID
        )
    }
}

extension ElasticsearchService.ListElasticsearchInstanceTypesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.ListElasticsearchInstanceTypesRequest {
        return .init(
            domainName: self.domainName,
            elasticsearchVersion: self.elasticsearchVersion,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.ListElasticsearchVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.ListElasticsearchVersionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension ElasticsearchService.ListPackagesForDomainRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> ElasticsearchService.ListPackagesForDomainRequest {
        return .init(
            domainName: self.domainName,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
